package com.liang.pcc.util;

import java.math.BigDecimal;
import java.util.*;

public class TreeCalculator {
    private static final Map<Long, TreeNode> nodeMap = new HashMap<>();

    /**
     * 计算所有母线节点的 maxReverseLoadRate 和 minIndependentMountable
     */
    public static void calculateBusValues(List<TreeNode> roots) {
        if (roots.isEmpty()) return;

        // 1. 构建节点ID与对象的映射
        nodeMap.clear();
        buildNodeMap(roots.get(0)); // 假设只有一个根节点

        // 2. 处理根节点（规则1）
        TreeNode root = roots.get(0);
        processRootNode(root);

        // 3. 处理非根母线节点（规则2）
        for (TreeNode node : nodeMap.values()) {
            if (isNonRootBus(node, root)) {
                List<TreeNode> path = getPathFromRoot(node);
                calculateAndSetValues(node, path);
            }
        }
    }

    // 构建节点ID与对象的映射
    private static void buildNodeMap(TreeNode node) {
        nodeMap.put(node.getId(), node);
        for (TreeNode child : node.getChildren()) {
            buildNodeMap(child);
        }
    }

    // 规则1：处理根节点
    private static void processRootNode(TreeNode root) {
        if (!root.getChildren().isEmpty()) {
            TreeNode firstChild = root.getChildren().get(0);
            root.setMaxReverseLoadRate(firstChild.getMaxReverseLoadRate());
            root.setMinIndependentMountable(firstChild.getMinIndependentMountable());
        }
    }

    // 判断是否是非根母线节点
    private static boolean isNonRootBus(TreeNode node, TreeNode root) {
        return node != root && node.getType() == 0;
    }

    // 获取从根到当前节点的路径（包含当前节点）
    private static List<TreeNode> getPathFromRoot(TreeNode node) {
        List<TreeNode> path = new ArrayList<>();
        TreeNode current = node;
        while (current != null) {
            path.add(current);
            if (current.getParentId() == -1) break; // 根节点结束
            current = nodeMap.get(current.getParentId());
        }
        Collections.reverse(path); // 调整为从根到当前节点
        return path;
    }

    // 计算并设置节点的值（规则2）
    private static void calculateAndSetValues(TreeNode node, List<TreeNode> path) {
        if (path.isEmpty()) return;

        // 初始化为路径第一个节点的值（根节点）
        BigDecimal maxReverseLoadRate = getSafeValue(path.get(0).getMaxReverseLoadRate());
        BigDecimal minIndependentMountable = getSafeValue(path.get(0).getMinIndependentMountable());

        // 遍历路径后续节点，更新最大值和最小值
        for (int i = 1; i < path.size(); i++) {
            TreeNode pathNode = path.get(i);
            BigDecimal currentMax = getSafeValue(pathNode.getMaxReverseLoadRate());
            BigDecimal currentMin = getSafeValue(pathNode.getMinIndependentMountable());

            if (currentMax.compareTo(maxReverseLoadRate) > 0) {
                maxReverseLoadRate = currentMax;
            }
            if (currentMin.compareTo(minIndependentMountable) < 0) {
                minIndependentMountable = currentMin;
            }
        }

        node.setMaxReverseLoadRate(maxReverseLoadRate);
        node.setMinIndependentMountable(minIndependentMountable);
    }

    // 处理 null 值，默认返回 BigDecimal.ZERO
    private static BigDecimal getSafeValue(BigDecimal value) {
        return value != null ? value : BigDecimal.ZERO;
    }
}